// $ANTLR 3.4 C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g 2012-10-25 16:36:53
package PL.practica6;

import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked"})
public class AnalizadorANTLRParser extends Parser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "ABRIRLLAVE", "ABRIRPARENTESIS", "ARROBA", "ASTERISCO", "BLANCO", "CARACTER", "CERRARLLAVE", "CERRARPARENTESIS", "COMENTARIO", "COMENTARIOlINEA", "DIGITO", "DOSPUNTOS", "GRAMMAR", "HEADER", "IDENT", "IDENTREGLA", "IDENTTOKEN", "IGUAL", "IMPORT", "INTERROGANTE", "LETRA", "LETRAMAYUSCULA", "LETRAMINUSCULA", "MEMBERS", "NUEVA_LINEA", "OPERADORUNITARIO", "OPTIONS", "OR", "PACKAGE", "PARSER", "SEPARADOR", "SUMA"
    };

    public static final int EOF=-1;
    public static final int ABRIRLLAVE=4;
    public static final int ABRIRPARENTESIS=5;
    public static final int ARROBA=6;
    public static final int ASTERISCO=7;
    public static final int BLANCO=8;
    public static final int CARACTER=9;
    public static final int CERRARLLAVE=10;
    public static final int CERRARPARENTESIS=11;
    public static final int COMENTARIO=12;
    public static final int COMENTARIOlINEA=13;
    public static final int DIGITO=14;
    public static final int DOSPUNTOS=15;
    public static final int GRAMMAR=16;
    public static final int HEADER=17;
    public static final int IDENT=18;
    public static final int IDENTREGLA=19;
    public static final int IDENTTOKEN=20;
    public static final int IGUAL=21;
    public static final int IMPORT=22;
    public static final int INTERROGANTE=23;
    public static final int LETRA=24;
    public static final int LETRAMAYUSCULA=25;
    public static final int LETRAMINUSCULA=26;
    public static final int MEMBERS=27;
    public static final int NUEVA_LINEA=28;
    public static final int OPERADORUNITARIO=29;
    public static final int OPTIONS=30;
    public static final int OR=31;
    public static final int PACKAGE=32;
    public static final int PARSER=33;
    public static final int SEPARADOR=34;
    public static final int SUMA=35;

    // delegates
    public Parser[] getDelegates() {
        return new Parser[] {};
    }

    // delegators


    public AnalizadorANTLRParser(TokenStream input) {
        this(input, new RecognizerSharedState());
    }
    public AnalizadorANTLRParser(TokenStream input, RecognizerSharedState state) {
        super(input, state);
    }

    public String[] getTokenNames() { return AnalizadorANTLRParser.tokenNames; }
    public String getGrammarFileName() { return "C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g"; }



    ArrayList <RecognitionException> errores = new ArrayList<RecognitionException>();

    public boolean listaVacia (){
        if (errores.isEmpty()){
          return true;
        }else
          return false;
    }

    public ArrayList getListaErrores(){return errores;}


    @Override
    public void reportError (RecognitionException e){
      System.out.println (getErrorMessage(e, getTokenNames()));
      errores.add(e);
    }




    // $ANTLR start "entrada"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:1: entrada : ( tipoanalizador )? ( opciones )? ( cabecera )? ( regla )* ;
    public final void entrada() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:8: ( ( tipoanalizador )? ( opciones )? ( cabecera )? ( regla )* )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:10: ( tipoanalizador )? ( opciones )? ( cabecera )? ( regla )*
            {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:10: ( tipoanalizador )?
            int alt1=2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0==PARSER) ) {
                alt1=1;
            }
            switch (alt1) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:10: tipoanalizador
                    {
                    pushFollow(FOLLOW_tipoanalizador_in_entrada44);
                    tipoanalizador();

                    state._fsp--;


                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:26: ( opciones )?
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==OPTIONS) ) {
                alt2=1;
            }
            switch (alt2) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:26: opciones
                    {
                    pushFollow(FOLLOW_opciones_in_entrada47);
                    opciones();

                    state._fsp--;


                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:36: ( cabecera )?
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==ARROBA) ) {
                alt3=1;
            }
            switch (alt3) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:36: cabecera
                    {
                    pushFollow(FOLLOW_cabecera_in_entrada50);
                    cabecera();

                    state._fsp--;


                    }
                    break;

            }


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:46: ( regla )*
            loop4:
            do {
                int alt4=2;
                int LA4_0 = input.LA(1);

                if ( (LA4_0==IDENTREGLA) ) {
                    alt4=1;
                }


                switch (alt4) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:31:46: regla
            	    {
            	    pushFollow(FOLLOW_regla_in_entrada53);
            	    regla();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop4;
                }
            } while (true);


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "entrada"



    // $ANTLR start "tipoanalizador"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:32:3: tipoanalizador : PARSER GRAMMAR IDENT SEPARADOR ;
    public final void tipoanalizador() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:32:18: ( PARSER GRAMMAR IDENT SEPARADOR )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:32:20: PARSER GRAMMAR IDENT SEPARADOR
            {
            match(input,PARSER,FOLLOW_PARSER_in_tipoanalizador63); 

            match(input,GRAMMAR,FOLLOW_GRAMMAR_in_tipoanalizador65); 

            match(input,IDENT,FOLLOW_IDENT_in_tipoanalizador67); 

            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_tipoanalizador69); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "tipoanalizador"



    // $ANTLR start "opciones"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:33:3: opciones : OPTIONS ABRIRLLAVE ( IDENT IGUAL IDENT SEPARADOR )* CERRARLLAVE ;
    public final void opciones() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:33:12: ( OPTIONS ABRIRLLAVE ( IDENT IGUAL IDENT SEPARADOR )* CERRARLLAVE )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:33:14: OPTIONS ABRIRLLAVE ( IDENT IGUAL IDENT SEPARADOR )* CERRARLLAVE
            {
            match(input,OPTIONS,FOLLOW_OPTIONS_in_opciones78); 

            match(input,ABRIRLLAVE,FOLLOW_ABRIRLLAVE_in_opciones80); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:33:33: ( IDENT IGUAL IDENT SEPARADOR )*
            loop5:
            do {
                int alt5=2;
                int LA5_0 = input.LA(1);

                if ( (LA5_0==IDENT) ) {
                    alt5=1;
                }


                switch (alt5) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:33:34: IDENT IGUAL IDENT SEPARADOR
            	    {
            	    match(input,IDENT,FOLLOW_IDENT_in_opciones83); 

            	    match(input,IGUAL,FOLLOW_IGUAL_in_opciones85); 

            	    match(input,IDENT,FOLLOW_IDENT_in_opciones87); 

            	    match(input,SEPARADOR,FOLLOW_SEPARADOR_in_opciones89); 

            	    }
            	    break;

            	default :
            	    break loop5;
                }
            } while (true);


            match(input,CERRARLLAVE,FOLLOW_CERRARLLAVE_in_opciones93); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "opciones"



    // $ANTLR start "cabecera"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:34:3: cabecera : ARROBA HEADER ABRIRLLAVE ( ( IMPORT | PACKAGE ) IDENT SEPARADOR )* CERRARLLAVE ;
    public final void cabecera() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:34:12: ( ARROBA HEADER ABRIRLLAVE ( ( IMPORT | PACKAGE ) IDENT SEPARADOR )* CERRARLLAVE )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:34:14: ARROBA HEADER ABRIRLLAVE ( ( IMPORT | PACKAGE ) IDENT SEPARADOR )* CERRARLLAVE
            {
            match(input,ARROBA,FOLLOW_ARROBA_in_cabecera102); 

            match(input,HEADER,FOLLOW_HEADER_in_cabecera104); 

            match(input,ABRIRLLAVE,FOLLOW_ABRIRLLAVE_in_cabecera106); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:34:39: ( ( IMPORT | PACKAGE ) IDENT SEPARADOR )*
            loop6:
            do {
                int alt6=2;
                int LA6_0 = input.LA(1);

                if ( (LA6_0==IMPORT||LA6_0==PACKAGE) ) {
                    alt6=1;
                }


                switch (alt6) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:34:40: ( IMPORT | PACKAGE ) IDENT SEPARADOR
            	    {
            	    if ( input.LA(1)==IMPORT||input.LA(1)==PACKAGE ) {
            	        input.consume();
            	        state.errorRecovery=false;
            	    }
            	    else {
            	        MismatchedSetException mse = new MismatchedSetException(null,input);
            	        throw mse;
            	    }


            	    match(input,IDENT,FOLLOW_IDENT_in_cabecera115); 

            	    match(input,SEPARADOR,FOLLOW_SEPARADOR_in_cabecera117); 

            	    }
            	    break;

            	default :
            	    break loop6;
                }
            } while (true);


            match(input,CERRARLLAVE,FOLLOW_CERRARLLAVE_in_cabecera122); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "cabecera"



    // $ANTLR start "regla"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:35:1: regla : IDENTREGLA DOSPUNTOS ( reglasimple | reglaor | reglaconjunta )* SEPARADOR ;
    public final void regla() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:35:7: ( IDENTREGLA DOSPUNTOS ( reglasimple | reglaor | reglaconjunta )* SEPARADOR )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:35:9: IDENTREGLA DOSPUNTOS ( reglasimple | reglaor | reglaconjunta )* SEPARADOR
            {
            match(input,IDENTREGLA,FOLLOW_IDENTREGLA_in_regla129); 

            match(input,DOSPUNTOS,FOLLOW_DOSPUNTOS_in_regla131); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:35:31: ( reglasimple | reglaor | reglaconjunta )*
            loop7:
            do {
                int alt7=4;
                alt7 = dfa7.predict(input);
                switch (alt7) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:35:32: reglasimple
            	    {
            	    pushFollow(FOLLOW_reglasimple_in_regla135);
            	    reglasimple();

            	    state._fsp--;


            	    }
            	    break;
            	case 2 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:35:44: reglaor
            	    {
            	    pushFollow(FOLLOW_reglaor_in_regla137);
            	    reglaor();

            	    state._fsp--;


            	    }
            	    break;
            	case 3 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:35:52: reglaconjunta
            	    {
            	    pushFollow(FOLLOW_reglaconjunta_in_regla139);
            	    reglaconjunta();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    break loop7;
                }
            } while (true);


            match(input,SEPARADOR,FOLLOW_SEPARADOR_in_regla143); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "regla"



    // $ANTLR start "reglasimple"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:36:3: reglasimple : ( IDENTTOKEN | IDENTREGLA ( OPERADORUNITARIO )? );
    public final void reglasimple() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:36:15: ( IDENTTOKEN | IDENTREGLA ( OPERADORUNITARIO )? )
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0==IDENTTOKEN) ) {
                alt9=1;
            }
            else if ( (LA9_0==IDENTREGLA) ) {
                alt9=2;
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;

            }
            switch (alt9) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:36:17: IDENTTOKEN
                    {
                    match(input,IDENTTOKEN,FOLLOW_IDENTTOKEN_in_reglasimple152); 

                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:36:28: IDENTREGLA ( OPERADORUNITARIO )?
                    {
                    match(input,IDENTREGLA,FOLLOW_IDENTREGLA_in_reglasimple154); 

                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:36:39: ( OPERADORUNITARIO )?
                    int alt8=2;
                    int LA8_0 = input.LA(1);

                    if ( (LA8_0==OPERADORUNITARIO) ) {
                        alt8=1;
                    }
                    switch (alt8) {
                        case 1 :
                            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:36:39: OPERADORUNITARIO
                            {
                            match(input,OPERADORUNITARIO,FOLLOW_OPERADORUNITARIO_in_reglasimple156); 

                            }
                            break;

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "reglasimple"



    // $ANTLR start "reglaor"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:37:3: reglaor : ABRIRPARENTESIS reglasimple ( OR reglasimple )+ CERRARPARENTESIS ( OPERADORUNITARIO )? ;
    public final void reglaor() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:37:11: ( ABRIRPARENTESIS reglasimple ( OR reglasimple )+ CERRARPARENTESIS ( OPERADORUNITARIO )? )
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:37:13: ABRIRPARENTESIS reglasimple ( OR reglasimple )+ CERRARPARENTESIS ( OPERADORUNITARIO )?
            {
            match(input,ABRIRPARENTESIS,FOLLOW_ABRIRPARENTESIS_in_reglaor166); 

            pushFollow(FOLLOW_reglasimple_in_reglaor168);
            reglasimple();

            state._fsp--;


            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:37:41: ( OR reglasimple )+
            int cnt10=0;
            loop10:
            do {
                int alt10=2;
                int LA10_0 = input.LA(1);

                if ( (LA10_0==OR) ) {
                    alt10=1;
                }


                switch (alt10) {
            	case 1 :
            	    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:37:42: OR reglasimple
            	    {
            	    match(input,OR,FOLLOW_OR_in_reglaor171); 

            	    pushFollow(FOLLOW_reglasimple_in_reglaor173);
            	    reglasimple();

            	    state._fsp--;


            	    }
            	    break;

            	default :
            	    if ( cnt10 >= 1 ) break loop10;
                        EarlyExitException eee =
                            new EarlyExitException(10, input);
                        throw eee;
                }
                cnt10++;
            } while (true);


            match(input,CERRARPARENTESIS,FOLLOW_CERRARPARENTESIS_in_reglaor178); 

            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:37:77: ( OPERADORUNITARIO )?
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==OPERADORUNITARIO) ) {
                alt11=1;
            }
            switch (alt11) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:37:77: OPERADORUNITARIO
                    {
                    match(input,OPERADORUNITARIO,FOLLOW_OPERADORUNITARIO_in_reglaor180); 

                    }
                    break;

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "reglaor"



    // $ANTLR start "reglaconjunta"
    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:38:3: reglaconjunta : ( ABRIRPARENTESIS reglasimple | reglaor CERRARPARENTESIS );
    public final void reglaconjunta() throws RecognitionException {
        try {
            // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:38:17: ( ABRIRPARENTESIS reglasimple | reglaor CERRARPARENTESIS )
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0==ABRIRPARENTESIS) ) {
                int LA12_1 = input.LA(2);

                if ( (LA12_1==IDENTTOKEN) ) {
                    int LA12_2 = input.LA(3);

                    if ( (LA12_2==ABRIRPARENTESIS||(LA12_2 >= IDENTREGLA && LA12_2 <= IDENTTOKEN)||LA12_2==SEPARADOR) ) {
                        alt12=1;
                    }
                    else if ( (LA12_2==OR) ) {
                        alt12=2;
                    }
                    else {
                        NoViableAltException nvae =
                            new NoViableAltException("", 12, 2, input);

                        throw nvae;

                    }
                }
                else if ( (LA12_1==IDENTREGLA) ) {
                    switch ( input.LA(3) ) {
                    case OPERADORUNITARIO:
                        {
                        int LA12_6 = input.LA(4);

                        if ( (LA12_6==ABRIRPARENTESIS||(LA12_6 >= IDENTREGLA && LA12_6 <= IDENTTOKEN)||LA12_6==SEPARADOR) ) {
                            alt12=1;
                        }
                        else if ( (LA12_6==OR) ) {
                            alt12=2;
                        }
                        else {
                            NoViableAltException nvae =
                                new NoViableAltException("", 12, 6, input);

                            throw nvae;

                        }
                        }
                        break;
                    case ABRIRPARENTESIS:
                    case IDENTREGLA:
                    case IDENTTOKEN:
                    case SEPARADOR:
                        {
                        alt12=1;
                        }
                        break;
                    case OR:
                        {
                        alt12=2;
                        }
                        break;
                    default:
                        NoViableAltException nvae =
                            new NoViableAltException("", 12, 3, input);

                        throw nvae;

                    }

                }
                else {
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 1, input);

                    throw nvae;

                }
            }
            else {
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;

            }
            switch (alt12) {
                case 1 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:38:19: ABRIRPARENTESIS reglasimple
                    {
                    match(input,ABRIRPARENTESIS,FOLLOW_ABRIRPARENTESIS_in_reglaconjunta190); 

                    pushFollow(FOLLOW_reglasimple_in_reglaconjunta192);
                    reglasimple();

                    state._fsp--;


                    }
                    break;
                case 2 :
                    // C:\\Users\\Jose\\workspace\\practica6\\src\\main\\java\\PL\\practica6\\AnalizadorANTLRParser.g:38:47: reglaor CERRARPARENTESIS
                    {
                    pushFollow(FOLLOW_reglaor_in_reglaconjunta194);
                    reglaor();

                    state._fsp--;


                    match(input,CERRARPARENTESIS,FOLLOW_CERRARPARENTESIS_in_reglaconjunta196); 

                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }

        finally {
        	// do for sure before leaving
        }
        return ;
    }
    // $ANTLR end "reglaconjunta"

    // Delegated rules


    protected DFA7 dfa7 = new DFA7(this);
    static final String DFA7_eotS =
        "\17\uffff";
    static final String DFA7_eofS =
        "\17\uffff";
    static final String DFA7_minS =
        "\1\5\2\uffff\1\23\2\5\1\23\1\uffff\1\5\2\13\1\5\1\13\1\5\1\uffff";
    static final String DFA7_maxS =
        "\1\42\2\uffff\1\24\2\42\1\24\1\uffff\1\42\2\37\1\42\1\37\1\42\1"+
        "\uffff";
    static final String DFA7_acceptS =
        "\1\uffff\1\4\1\1\4\uffff\1\3\6\uffff\1\2";
    static final String DFA7_specialS =
        "\17\uffff}>";
    static final String[] DFA7_transitionS = {
            "\1\3\15\uffff\2\2\15\uffff\1\1",
            "",
            "",
            "\1\5\1\4",
            "\1\7\15\uffff\2\7\12\uffff\1\6\2\uffff\1\7",
            "\1\7\15\uffff\2\7\10\uffff\1\10\1\uffff\1\6\2\uffff\1\7",
            "\1\12\1\11",
            "",
            "\1\7\15\uffff\2\7\12\uffff\1\6\2\uffff\1\7",
            "\1\13\23\uffff\1\6",
            "\1\13\21\uffff\1\14\1\uffff\1\6",
            "\1\16\5\uffff\1\7\7\uffff\2\16\10\uffff\1\15\4\uffff\1\16",
            "\1\13\23\uffff\1\6",
            "\1\16\5\uffff\1\7\7\uffff\2\16\15\uffff\1\16",
            ""
    };

    static final short[] DFA7_eot = DFA.unpackEncodedString(DFA7_eotS);
    static final short[] DFA7_eof = DFA.unpackEncodedString(DFA7_eofS);
    static final char[] DFA7_min = DFA.unpackEncodedStringToUnsignedChars(DFA7_minS);
    static final char[] DFA7_max = DFA.unpackEncodedStringToUnsignedChars(DFA7_maxS);
    static final short[] DFA7_accept = DFA.unpackEncodedString(DFA7_acceptS);
    static final short[] DFA7_special = DFA.unpackEncodedString(DFA7_specialS);
    static final short[][] DFA7_transition;

    static {
        int numStates = DFA7_transitionS.length;
        DFA7_transition = new short[numStates][];
        for (int i=0; i<numStates; i++) {
            DFA7_transition[i] = DFA.unpackEncodedString(DFA7_transitionS[i]);
        }
    }

    class DFA7 extends DFA {

        public DFA7(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 7;
            this.eot = DFA7_eot;
            this.eof = DFA7_eof;
            this.min = DFA7_min;
            this.max = DFA7_max;
            this.accept = DFA7_accept;
            this.special = DFA7_special;
            this.transition = DFA7_transition;
        }
        public String getDescription() {
            return "()* loopback of 35:31: ( reglasimple | reglaor | reglaconjunta )*";
        }
    }
 

    public static final BitSet FOLLOW_tipoanalizador_in_entrada44 = new BitSet(new long[]{0x0000000040080042L});
    public static final BitSet FOLLOW_opciones_in_entrada47 = new BitSet(new long[]{0x0000000000080042L});
    public static final BitSet FOLLOW_cabecera_in_entrada50 = new BitSet(new long[]{0x0000000000080002L});
    public static final BitSet FOLLOW_regla_in_entrada53 = new BitSet(new long[]{0x0000000000080002L});
    public static final BitSet FOLLOW_PARSER_in_tipoanalizador63 = new BitSet(new long[]{0x0000000000010000L});
    public static final BitSet FOLLOW_GRAMMAR_in_tipoanalizador65 = new BitSet(new long[]{0x0000000000040000L});
    public static final BitSet FOLLOW_IDENT_in_tipoanalizador67 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_tipoanalizador69 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_OPTIONS_in_opciones78 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ABRIRLLAVE_in_opciones80 = new BitSet(new long[]{0x0000000000040400L});
    public static final BitSet FOLLOW_IDENT_in_opciones83 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_IGUAL_in_opciones85 = new BitSet(new long[]{0x0000000000040000L});
    public static final BitSet FOLLOW_IDENT_in_opciones87 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_opciones89 = new BitSet(new long[]{0x0000000000040400L});
    public static final BitSet FOLLOW_CERRARLLAVE_in_opciones93 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ARROBA_in_cabecera102 = new BitSet(new long[]{0x0000000000020000L});
    public static final BitSet FOLLOW_HEADER_in_cabecera104 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_ABRIRLLAVE_in_cabecera106 = new BitSet(new long[]{0x0000000100400400L});
    public static final BitSet FOLLOW_set_in_cabecera109 = new BitSet(new long[]{0x0000000000040000L});
    public static final BitSet FOLLOW_IDENT_in_cabecera115 = new BitSet(new long[]{0x0000000400000000L});
    public static final BitSet FOLLOW_SEPARADOR_in_cabecera117 = new BitSet(new long[]{0x0000000100400400L});
    public static final BitSet FOLLOW_CERRARLLAVE_in_cabecera122 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTREGLA_in_regla129 = new BitSet(new long[]{0x0000000000008000L});
    public static final BitSet FOLLOW_DOSPUNTOS_in_regla131 = new BitSet(new long[]{0x0000000400180020L});
    public static final BitSet FOLLOW_reglasimple_in_regla135 = new BitSet(new long[]{0x0000000400180020L});
    public static final BitSet FOLLOW_reglaor_in_regla137 = new BitSet(new long[]{0x0000000400180020L});
    public static final BitSet FOLLOW_reglaconjunta_in_regla139 = new BitSet(new long[]{0x0000000400180020L});
    public static final BitSet FOLLOW_SEPARADOR_in_regla143 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTTOKEN_in_reglasimple152 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_IDENTREGLA_in_reglasimple154 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_OPERADORUNITARIO_in_reglasimple156 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ABRIRPARENTESIS_in_reglaor166 = new BitSet(new long[]{0x0000000000180000L});
    public static final BitSet FOLLOW_reglasimple_in_reglaor168 = new BitSet(new long[]{0x0000000080000000L});
    public static final BitSet FOLLOW_OR_in_reglaor171 = new BitSet(new long[]{0x0000000000180000L});
    public static final BitSet FOLLOW_reglasimple_in_reglaor173 = new BitSet(new long[]{0x0000000080000800L});
    public static final BitSet FOLLOW_CERRARPARENTESIS_in_reglaor178 = new BitSet(new long[]{0x0000000020000002L});
    public static final BitSet FOLLOW_OPERADORUNITARIO_in_reglaor180 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ABRIRPARENTESIS_in_reglaconjunta190 = new BitSet(new long[]{0x0000000000180000L});
    public static final BitSet FOLLOW_reglasimple_in_reglaconjunta192 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_reglaor_in_reglaconjunta194 = new BitSet(new long[]{0x0000000000000800L});
    public static final BitSet FOLLOW_CERRARPARENTESIS_in_reglaconjunta196 = new BitSet(new long[]{0x0000000000000002L});

}